/**  
 * youmu Service Inc
 * All Rights Reserved @2017
 *
 */
package com.youmu.shop.json.utils;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.beans.BeanUtils;
import org.springframework.util.StringUtils;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.gson.GsonBuilder;
import com.google.gson.reflect.TypeToken;

/**
 * 
 * @author yujiahao
 * @version $Id: JSONUtil.java, v 0.1 2017年2月27日 下午6:09:14 yujiahao Exp $
 */
public class JacksonUtil {
    
    public static Map JSON2Map(String string){
        ObjectMapper mapper = new ObjectMapper();
        Map<String,Object> m = new HashMap<String, Object>();
        try {  
            m = mapper.readValue(string, Map.class);  
        } catch (JsonParseException e) {  
            e.printStackTrace();  
        } catch (JsonMappingException e1) {  
            e1.printStackTrace();  
        } catch (IOException e2) {  
            e2.printStackTrace();  
        }
        return m;
    }
    
    /**
	 * 利用spring工具类将两个bean对象对应转换,注意调用强制转换
	 * 
	 * @param <BOUser>
	 * @param source
	 *            源javabean对象
	 * @param target
	 *            目标javabean对象
	 * @return
	 */
	public static <T> T exchangeObject(Object source, Class<T> target) {
		if (StringUtils.isEmpty(source)) {
			return null;
		}
		T t = null;
		try {
			t = target.newInstance();
		} catch (InstantiationException | IllegalAccessException e) {
			e.printStackTrace();
		}
		BeanUtils.copyProperties(source, t);
		return t;
	}
    
	/**
	 * Gson获取json中的数组节点.<br/>
	 * 将数组节点转换为list集合<泛型>.<br/>
	 * 泛型类，是在实例化类的时候指明泛型的具体类型.<br/>
	 * 泛型方法，是在调用方法的时候指明泛型的具体类型.<br/>
	 * @author Tony_tian
	 * @time 2016-03-15 09:44:32
	 * */
	/**
	 * Gson获取json中的数组节点.转换为list集合<泛型>.<br/>
	 * @param <T> 声明一个泛型T
	 * @param List<T> 指明该方法的返回值为泛型T代表类型的list集合
	 * @param jsonStr json中的数组节点
	 * @param tC 指明泛型T的具体类型，用来创建泛型T代表的类的对象
	 * @return 1:正常返回泛型代表具体类型的list集合，2:转换错误则返回null
	 * */
	@SuppressWarnings("unchecked")
	public static final <T> List<T> json2listT(String jsonStr, Class<T> clazz) {
		//json字符串不能为空
		if(StringUtils.isEmpty(jsonStr)) return null;
		//json字符串必须为数组节点类型
		if(!(jsonStr.startsWith("[") && jsonStr.endsWith("]"))) return null;
		List<T> listT = null;
		try {
			//创建泛型对象
			T t =  clazz.newInstance();
			//利用类加载加载泛型的具体类型
			Class<T> classT = (Class<T>) Class.forName(t.getClass().getName());
			List<Object> listObj = new ArrayList<Object>();
			//将数组节点中json字符串转换为object对象到Object的list集合
			listObj = new GsonBuilder().create().fromJson(jsonStr, new TypeToken<List<Object>>(){}.getType());
			//转换未成功
			if(listObj == null || listObj.isEmpty()) return null;
			listT = new ArrayList<T>();
			//将Object的list中的的每一个元素中的json字符串转换为泛型代表的类型加入泛型代表的list集合返回
			for (Object obj : listObj) {
				T perT = new GsonBuilder().create().fromJson(obj.toString(), classT);
				listT.add(perT);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return listT;
	}
    
}
